﻿//template < class T,                        // set::key_type/value_type
//    class Compare = less<T>,        // set::key_compare/value_compare
//    class Alloc = allocator<T>      // set::allocator_type
//> class set;
// 
// empty (1) ⽆参默认构造
//explicit set(const key_compare& comp = key_compare(),
//	const allocator_type& alloc = allocator_type());
//// range (2) 迭代器区间构造
//template <class InputIterator>
//set(InputIterator first, InputIterator last,
//	const key_compare& comp = key_compare(),
//	const allocator_type & = allocator_type());
//// copy (3) 拷⻉构造
//set(const set& x);
//// initializer list (5) initializer 列表构造
//set(initializer_list<value_type> il,
//	const key_compare& comp = key_compare(),
//	const allocator_type& alloc = allocator_type());
//// 迭代器是⼀个双向迭代器
//iterator->a bidirectional iterator to const value_type
//// 正向迭代器
//iterator begin();
//iterator end();
//// 反向迭代器
//reverse_iterator rbegin();
//reverse_iterator rend();
//Member types
//key_type->The first template parameter(T)
//value_type->The first template parameter(T)
//// 单个数据插⼊，如果已经存在则插⼊失败
//pair<iterator, bool> insert(const value_type& val);
//// 列表插⼊，已经在容器中存在的值不会插⼊
//void insert(initializer_list<value_type> il);
//// 迭代器区间插⼊，已经在容器中存在的值不会插⼊
//template <class InputIterator>
//void insert(InputIterator first, InputIterator last);
//// 查找val，返回val所在的迭代器，没有找到返回end()
//iterator find(const value_type& val);
//// 查找val，返回Val的个数
//size_type count(const value_type& val) const;
//// 删除⼀个迭代器位置的值
//iterator erase(const_iterator position);
//// 删除val，val不存在返回0，存在返回1
//size_type erase(const value_type& val);
//// 删除⼀段迭代器区间的值
//iterator erase(const_iterator first, const_iterator last);
//// 返回⼤于等val位置的迭代器
//iterator lower_bound(const value_type& val) const;
//// 返回⼤于val位置的迭代器
//iterator upper_bound(const value_type& val) const;
//template < class Key,                                     // map::key_type
//    class T,                                       // map::mapped_type
//    class Compare = less<Key>,                     // map::key_compare
//    class Alloc = allocator<pair<const Key, T> >    // map::allocator_type
//> class map;
//typedef pair<const Key, T> value_type;
//
//template <class T1, class T2>
//struct pair
//{
//	typedef T1 first_type;
//	typedef T2 second_type;
//
//	T1 first;
//	T2 second;
//
//	pair() : first(T1()), second(T2())
//	{
//	}
//
//	pair(const T1& a, const T2& b) : first(a), second(b)
//	{
//	}
//
//	template<class U, class V>
//	pair(const pair<U, V>& pr) : first(pr.first), second(pr.second)
//	{
//	}
//};
//
//template <class T1, class T2>
//inline pair<T1, T2> make_pair(T1 x, T2 y)
//{
//	return (pair<T1, T2>(x, y));
//}

// empty (1) ⽆参默认构造
//explicit map(const key_compare& comp = key_compare(),
//	const allocator_type& alloc = allocator_type());
//
//// range (2) 迭代器区间构造
//template <class InputIterator>
//map(InputIterator first, InputIterator last,
//	const key_compare& comp = key_compare(),
//	const allocator_type & = allocator_type());
//// copy (3) 拷⻉构造
//map(const map& x);
//
//// initializer list (5) initializer 列表构造
//map(initializer_list<value_type> il,
//	const key_compare& comp = key_compare(),
//	const allocator_type& alloc = allocator_type());
//
//// 迭代器是⼀个双向迭代器
//iterator->a bidirectional iterator to const value_type
//
//// 正向迭代器
//iterator begin();
//iterator end();
//// 反向迭代器
//reverse_iterator rbegin();
//reverse_iterator rend();
// 成员类型
//key_type->The first template parameter(Key)
//mapped_type->The second template parameter(T)
//value_type->pair<const key_type, mapped_type>
//
//// 单个数据插⼊，如果已经key存在则插⼊失败,key存在相等value不相等也会插⼊失败
//pair<iterator, bool> insert(const value_type& val);
//// 列表插⼊，已经在容器中存在的值不会插⼊
//void insert(initializer_list<value_type> il);
//// 迭代器区间插⼊，已经在容器中存在的值不会插⼊
//template <class InputIterator>
//void insert(InputIterator first, InputIterator last);
//
//// 查找k，返回k所在的迭代器，没有找到返回end()
//iterator find(const key_type& k);
//// 查找k，返回k的个数
//size_type count(const key_type& k) const;
//
//// 删除⼀个迭代器位置的值
//iterator erase(const_iterator position);
//// 删除k，k存在返回0，存在返回1
//size_type erase(const key_type& k);
//// 删除⼀段迭代器区间的值
//iterator erase(const_iterator first, const_iterator last);
//
//// 返回⼤于等k位置的迭代器
//iterator lower_bound(const key_type& k);
//// 返回⼤于k位置的迭代器
//const_iterator lower_bound(const key_type& k) const;
// Member types
key_type->The first template parameter(Key)
mapped_type->The second template parameter(T)
value_type->pair<const key_type, mapped_type>

// 查找k，返回k所在的迭代器，没有找到返回end()，如果找到了通过iterator可以修改key对应的
// mapped_type值
iterator find(const key_type& k);

// ⽂档中对insert返回值的说明
// The single element versions (1) return a pair, with its member pair::first
// set to an iterator pointing to either the newly inserted element or to the
// element with an equivalent key in the map. The pair::second element in the pair
// is set to true if a new element was inserted or false if an equivalent key
// already existed.
// insert插⼊⼀个pair<key, T>对象
// 1、如果key已经在map中，插⼊失败，则返回⼀个pair<iterator,bool>对象，返回pair对象
// first是key所在结点的迭代器，second是false
// 2、如果key不在在map中，插⼊成功，则返回⼀个pair<iterator,bool>对象，返回pair对象
// first是新插⼊key所在结点的迭代器，second是true
// 也就是说⽆论插⼊成功还是失败，返回pair<iterator,bool>对象的first都会指向key所在的迭
// 代器
// 那么也就意味着insert插⼊失败时充当了查找的功能，正是因为这⼀点，insert可以⽤来实现
// operator[]
// 需要注意的是这⾥有两个pair，不要混淆了，⼀个是map底层红⿊树节点中存的pair<key, T>，另
// ⼀个是insert返回值pair<iterator,bool>
pair<iterator, bool> insert(const value_type& val);

mapped_type& operator[] (const key_type& k);

// operator的内部实现
mapped_type& operator[] (const key_type& k)
{
    // 1、如果k不在map中，insert会插⼊k和mapped_type默认值，同时[]返回结点中存储
    // mapped_type值的引⽤，那么我们可以通过引⽤修改返映射值。所以[]具备了插⼊+修改功能
    // 2、如果k在map中，insert会插⼊失败，但是insert返回pair对象的first是指向key结点的
    // 迭代器，返回值同时[]返回结点中存储mapped_type值的引⽤，所以[]具备了查找+修改的功能
    pair<iterator, bool> ret = insert({ k, mapped_type() });
    iterator it = ret.first;
    return it->second;
}
